home *** CD-ROM | disk | FTP | other *** search
/ InterCD 2000 September / september_2000.iso / intercd / root / ^Linux / cdrtools-1.10 / lib / comerr.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-05-07  |  4.0 KB  |  211 lines
  1. /* @(#)comerr.c    1.22 00/05/07 Copyright 1985 J. Schilling */
  2. /*
  3.  *    Routines for printing command errors
  4.  *
  5.  *    Copyright (c) 1985 J. Schilling
  6.  */
  7. /*
  8.  * This program is free software; you can redistribute it and/or modify
  9.  * it under the terms of the GNU General Public License as published by
  10.  * the Free Software Foundation; either version 2, or (at your option)
  11.  * any later version.
  12.  *
  13.  * This program is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  * GNU General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU General Public License
  19.  * along with this program; see the file COPYING.  If not, write to
  20.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23. #include <mconfig.h>
  24. #include <stdio.h>
  25. #include <standard.h>
  26. #include <stdxlib.h>
  27. #include <vadefs.h>
  28. #include <strdefs.h>
  29. #include <schily.h>
  30. #ifndef    HAVE_STRERROR
  31. extern    char    *sys_errlist[];
  32. extern    int    sys_nerr;
  33. #endif
  34.  
  35. EXPORT    int    on_comerr    __PR((void (*fun)(int, void *), void *arg));
  36. EXPORT    void    comerr        __PR((const char *, ...));
  37. EXPORT    void    comerrno    __PR((int, const char *, ...));
  38. EXPORT    int    errmsg        __PR((const char *, ...));
  39. EXPORT    int    errmsgno    __PR((int, const char *, ...));
  40. LOCAL    int    _comerr        __PR((int, int, const char *, va_list));
  41. EXPORT    void    comexit        __PR((int));
  42. EXPORT    char    *errmsgstr    __PR((int));
  43.  
  44. typedef    struct ex {
  45.     struct ex *next;
  46.     void    (*func) __PR((int, void *));
  47.     void    *arg;
  48. } ex_t;
  49.  
  50. LOCAL    ex_t    *exfuncs;
  51.  
  52. EXPORT    int
  53. on_comerr(func, arg)
  54.     void    (*func) __PR((int, void *));
  55.     void    *arg;
  56. {
  57.     ex_t    *fp;
  58.  
  59.     fp = malloc(sizeof(*fp));
  60.     if (fp == NULL)
  61.         return (-1);
  62.  
  63.     fp->func = func;
  64.     fp->arg  = arg;
  65.     fp->next = exfuncs;
  66.     exfuncs = fp;
  67.     return (0);
  68. }
  69.  
  70. /* VARARGS1 */
  71. #ifdef    PROTOTYPES
  72. void comerr(const char *msg, ...)
  73. #else
  74. void comerr(msg, va_alist)
  75.     char    *msg;
  76.     va_dcl
  77. #endif
  78. {
  79.     va_list    args;
  80.  
  81. #ifdef    PROTOTYPES
  82.     va_start(args, msg);
  83. #else
  84.     va_start(args);
  85. #endif
  86.     (void)_comerr(TRUE, geterrno(), msg, args);
  87.     /* NOTREACHED */
  88.     va_end(args);
  89. }
  90.  
  91. /* VARARGS2 */
  92. #ifdef    PROTOTYPES
  93. void comerrno(int err, const char *msg, ...)
  94. #else
  95. void comerrno(err, msg, va_alist)
  96.     int    err;
  97.     char    *msg;
  98.     va_dcl
  99. #endif
  100. {
  101.     va_list    args;
  102.  
  103. #ifdef    PROTOTYPES
  104.     va_start(args, msg);
  105. #else
  106.     va_start(args);
  107. #endif
  108.     (void)_comerr(TRUE, err, msg, args);
  109.     /* NOTREACHED */
  110.     va_end(args);
  111. }
  112.  
  113. /* VARARGS1 */
  114. #ifdef    PROTOTYPES
  115. int errmsg(const char *msg, ...)
  116. #else
  117. int errmsg(msg, va_alist)
  118.     char    *msg;
  119.     va_dcl
  120. #endif
  121. {
  122.     va_list    args;
  123.     int    ret;
  124.  
  125. #ifdef    PROTOTYPES
  126.     va_start(args, msg);
  127. #else
  128.     va_start(args);
  129. #endif
  130.     ret = _comerr(FALSE, geterrno(), msg, args);
  131.     va_end(args);
  132.     return (ret);
  133. }
  134.  
  135. /* VARARGS2 */
  136. #ifdef    PROTOTYPES
  137. int errmsgno(int err, const char *msg, ...)
  138. #else
  139. int errmsgno(err, msg, va_alist)
  140.     int    err;
  141.     char    *msg;
  142.     va_dcl
  143. #endif
  144. {
  145.     va_list    args;
  146.     int    ret;
  147.  
  148. #ifdef    PROTOTYPES
  149.     va_start(args, msg);
  150. #else
  151.     va_start(args);
  152. #endif
  153.     ret = _comerr(FALSE, err, msg, args);
  154.     va_end(args);
  155.     return (ret);
  156. }
  157.  
  158. LOCAL int _comerr(exflg, err, msg, args)
  159.     int        exflg;
  160.     int        err;
  161.     const char    *msg;
  162.     va_list        args;
  163. {
  164.     char    errbuf[20];
  165.     char    *errnam;
  166.     char    *prognam = get_progname();
  167.     
  168.     if (err < 0) {
  169.         error("%s: %r", prognam, msg, args);
  170.     } else {
  171.         errnam = errmsgstr(err);
  172.         if (errnam == NULL) {
  173.             (void)sprintf(errbuf, "Error %d", err);
  174.             errnam = errbuf;
  175.         }
  176.         error("%s: %s. %r", prognam, errnam, msg, args);
  177.     }
  178.     if (exflg) {
  179.         comexit(err);
  180.         /* NOTREACHED */
  181.     }
  182.     return(err);
  183. }
  184.  
  185. EXPORT void
  186. comexit(err)
  187.     int    err;
  188. {
  189.     while (exfuncs) {
  190.         (*exfuncs->func)(err, exfuncs->arg);
  191.         exfuncs = exfuncs->next;
  192.     }
  193.     exit(err);
  194.     /* NOTREACHED */
  195. }
  196.  
  197. EXPORT char *
  198. errmsgstr(err)
  199.     int    err;
  200. {
  201. #ifdef    HAVE_STRERROR
  202.     return (strerror(err));
  203. #else
  204.     if (err < 0 || err >= sys_nerr) {
  205.         return (NULL);
  206.     } else {
  207.         return (sys_errlist[err]);
  208.     }
  209. #endif
  210. }
  211.